// 修复路径拼接问题的登录拦截器（保留参数版）
import store from './store.js'

// 页面绝对路径（必须以/开头，与pages.json对应）
const PAGES = {
  LOGIN: '/pages/login/login',
  INDEX: '/pages/index/index'
}

/**
 * 标准化路径为绝对路径（保留参数）
 * @param {string} url - 原始路径（可能含参数）
 * @returns {string} 标准化后的路径（含参数）
 */
function normalizePath(url) {
  // 分离路径和参数（保留 ? 后面的部分）
  const [pathPart, queryPart] = url.split('?')
  let purePath = pathPart || ''
  
  // 确保路径以 / 开头（绝对路径）
  if (!purePath.startsWith('/')) {
    purePath = '/' + purePath
  }
  
  // 拼接回参数（如果有）
  return queryPart ? `${purePath}?${queryPart}` : purePath
}

/**
 * 安全跳转方法（强制使用绝对路径，保留参数）
 * @param {string} url - 目标路径（可能含参数）
 * @returns {Promise} 跳转结果
 */
export function navigateToPage(url) {
  return new Promise((resolve, reject) => {
    const normalizedUrl = normalizePath(url)
    console.log('[跳转] 尝试跳转到：', normalizedUrl)

    // 检查页面路径（只校验纯路径，忽略参数）
    const purePath = normalizedUrl.split('?')[0]
    const isRegistered = Object.values(PAGES).includes(purePath)
    if (!isRegistered) {
      const err = new Error(`页面未注册：${purePath}（请在pages.json中配置）`)
      console.error('[跳转错误]', err.message)
      reject(err)
      return
    }

    // 使用redirectTo跳转（保留参数）
    uni.redirectTo({
      url: normalizedUrl, // 这里传入带参数的完整路径
      success: () => {
        console.log('[跳转成功] 已到达：', normalizedUrl)
        resolve()
      },
      fail: (err) => {
        console.error('[跳转失败] 到', normalizedUrl, '错误信息：', err)
        reject(err)
      }
    })
  })
}

/**
 * 拦截所有页面跳转方法（保留参数）
 */
function interceptNavigation() {
  // 拦截navigateTo
  uni.addInterceptor('navigateTo', {
    invoke(args) {
      const originalUrl = args.url
      const normalizedUrl = normalizePath(originalUrl) // 保留参数的标准化路径
      console.log('[拦截] navigateTo请求：', originalUrl, '→ 标准化后：', normalizedUrl)
      
      const purePath = normalizedUrl.split('?')[0] // 只取纯路径做权限判断
      const processed = processNavigation(purePath)
      
      // 如果需要跳转其他页面（如登录页），则不带参数；否则保留原参数
      args.url = processed.url === purePath ? normalizedUrl : processed.url
      return args
    }
  })

  // 拦截redirectTo（逻辑同上）
  uni.addInterceptor('redirectTo', {
    invoke(args) {
      const originalUrl = args.url
      const normalizedUrl = normalizePath(originalUrl)
      console.log('[拦截] redirectTo请求：', originalUrl, '→ 标准化后：', normalizedUrl)
      
      const purePath = normalizedUrl.split('?')[0]
      const processed = processNavigation(purePath)
      
      args.url = processed.url === purePath ? normalizedUrl : processed.url
      return args
    }
  })

  // 拦截switchTab（tab页通常不传递参数，保持原逻辑）
  uni.addInterceptor('switchTab', {
    invoke(args) {
      const targetPath = normalizePath(args.url).split('?')[0] // 忽略参数
      console.log('[拦截] switchTab请求：', targetPath)
      const processed = processNavigation(targetPath)
      if (processed.block) {
        return false // 阻止原跳转
      }
      args.url = processed.url
      return args
    }
  })
}

/**
 * 处理导航逻辑（判断登录状态并跳转）
 * @param {string} targetPath - 目标页面纯路径（不含参数）
 * @returns {Object} 处理结果（url: 实际跳转路径, block: 是否阻止原跳转）
 */
function processNavigation(targetPath) {
  const isLoggedIn = store.isLogin()

  // 已登录状态
  if (isLoggedIn) {
    // 已登录访问登录页 → 强制跳首页
    if (targetPath === PAGES.LOGIN) {
      console.log('[拦截] 已登录，禁止访问登录页，强制跳首页')
      return { url: PAGES.INDEX, block: false }
    }
  }

  // 未登录状态
  if (!isLoggedIn) {
    // 未登录访问首页 → 强制跳登录页
    if (targetPath === PAGES.INDEX) {
      console.log('[拦截] 未登录，禁止访问首页，强制跳登录页')
      return { url: PAGES.LOGIN, block: false }
    }
  }

  // 其他情况放行（保留原路径和参数）
  return { url: targetPath, block: false }
}

// 以下checkCurrentPage和initInterceptor逻辑不变...
function checkCurrentPage() {
  const maxRetries = 50
  const retryDelay = 30
  let retryCount = 0

  const check = () => {
    const pages = getCurrentPages()
    if (pages.length === 0) {
      if (retryCount < maxRetries) {
        retryCount++
        console.log(`[拦截] 页面未加载，第${retryCount}次重试...`)
        setTimeout(check, retryDelay)
        return
      } else {
        console.error('[拦截] 超过最大重试次数，无法获取当前页面')
        return
      }
    }

    const currentPage = pages[pages.length - 1]
    const currentPath = '/' + currentPage.route
    console.log('[拦截] 当前页面：', currentPath)

    if (store.isLogin() && currentPath === PAGES.LOGIN) {
      console.log('[拦截] 已登录但在登录页，自动跳首页')
      navigateToPage(PAGES.INDEX)
    }

    if (!store.isLogin() && currentPath === PAGES.INDEX) {
      console.log('[拦截] 未登录但在首页，自动跳登录页')
      navigateToPage(PAGES.LOGIN)
    }
  }

  check()
}

function initInterceptor() {
  console.log('[拦截] 初始化全局登录拦截器（保留参数版）')
  interceptNavigation()
  checkCurrentPage()
  console.log('[拦截] 初始化完成')
}

initInterceptor()

export default { initInterceptor }
